/*
 * Copyright (C) 2008 The Android Open Source Project
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package com.netthreads.android.opengl;

import java.io.Writer;
import java.util.ArrayList;
import java.util.concurrent.Semaphore;

import javax.microedition.khronos.egl.EGL10;
import javax.microedition.khronos.egl.EGL11;
import javax.microedition.khronos.egl.EGLConfig;
import javax.microedition.khronos.egl.EGLContext;
import javax.microedition.khronos.egl.EGLDisplay;
import javax.microedition.khronos.egl.EGLSurface;
import javax.microedition.khronos.opengles.GL;
import javax.microedition.khronos.opengles.GL10;

import com.netthreads.android.bulletml.ProfileRecorder;

import android.content.Context;
import android.opengl.GLDebugHelper;
import android.util.AttributeSet;
import android.util.Log;
import android.view.SurfaceHolder;
import android.view.SurfaceView;

/**
 * An implementation of SurfaceView that uses the dedicated surface for
 * displaying OpenGL rendering.
 * <p>
 * A GLSurfaceView provides the following features:
 * <p>
 * <ul>
 * <li>Manages a surface, which is a special piece of memory that can be
 * composited into the Android view system.
 * <li>Manages an EGL display, which enables OpenGL to render into a surface.
 * <li>Accepts a user-provided Renderer object that does the actual rendering.
 * <li>Renders on a dedicated thread to decouple rendering performance from the
 * UI thread.
 * <li>Supports both on-demand and continuous rendering.
 * <li>Optionally wraps, traces, and/or error-checks the renderer's OpenGL
 * calls.
 * </ul>
 * 
 * <h3>Using GLSurfaceView</h3>
 * <p>
 * Typically you use GLSurfaceView by subclassing it and overriding one or more
 * of the View system input event methods. If your application does not need to
 * override event methods then GLSurfaceView can be used as-is. For the most
 * part GLSurfaceView behavior is customized by calling "set" methods rather
 * than by subclassing. For example, unlike a regular View, drawing is delegated
 * to a separate Renderer object which is registered with the GLSurfaceView
 * using the {@link #setRenderer(Renderer)} call.
 * <p>
 * <h3>Initializing GLSurfaceView</h3>
 * All you have to do to initialize a GLSurfaceView is call
 * {@link #setRenderer(Renderer)}. However, if desired, you can modify the
 * default behavior of GLSurfaceView by calling one or more of these methods
 * before calling setRenderer:
 * <ul>
 * <li>{@link #setDebugFlags(int)}
 * <li>{@link #setEGLConfigChooser(boolean)}
 * <li>{@link #setEGLConfigChooser(EGLConfigChooser)}
 * <li>{@link #setEGLConfigChooser(int, int, int, int, int, int)}
 * <li>{@link #setGLWrapper(GLWrapper)}
 * </ul>
 * <p>
 * <h4>Choosing an EGL Configuration</h4>
 * A given Android device may support multiple possible types of drawing
 * surfaces. The available surfaces may differ in how may channels of data are
 * present, as well as how many bits are allocated to each channel. Therefore,
 * the first thing GLSurfaceView has to do when starting to render is choose
 * what type of surface to use.
 * <p>
 * By default GLSurfaceView chooses an available surface that's closest to a
 * 16-bit R5G6B5 surface with a 16-bit depth buffer and no stencil. If you would
 * prefer a different surface (for example, if you do not need a depth buffer)
 * you can override the default behavior by calling one of the
 * setEGLConfigChooser methods.
 * <p>
 * <h4>Debug Behavior</h4>
 * You can optionally modify the behavior of GLSurfaceView by calling one or
 * more of the debugging methods {@link #setDebugFlags(int)}, and
 * {@link #setGLWrapper}. These methods may be called before and/or after
 * setRenderer, but typically they are called before setRenderer so that they
 * take effect immediately.
 * <p>
 * <h4>Setting a Renderer</h4>
 * Finally, you must call {@link #setRenderer} to register a {@link Renderer}.
 * The renderer is responsible for doing the actual OpenGL rendering.
 * <p>
 * <h3>Rendering Mode</h3>
 * Once the renderer is set, you can control whether the renderer draws
 * continuously or on-demand by calling {@link #setRenderMode}. The default is
 * continuous rendering.
 * <p>
 * <h3>Activity Life-cycle</h3>
 * A GLSurfaceView must be notified when the activity is paused and resumed.
 * GLSurfaceView clients are required to call {@link #onPause()} when the
 * activity pauses and {@link #onResume()} when the activity resumes. These
 * calls allow GLSurfaceView to pause and resume the rendering thread, and also
 * allow GLSurfaceView to release and recreate the OpenGL display.
 * <p>
 * <h3>Handling events</h3>
 * <p>
 * To handle an event you will typically subclass GLSurfaceView and override the
 * appropriate method, just as you would with any other View. However, when
 * handling the event, you may need to communicate with the Renderer object
 * that's running in the rendering thread. You can do this using any standard
 * Java cross-thread communication mechanism. In addition, one relatively easy
 * way to communicate with your renderer is to call
 * {@link #queueEvent(Runnable)}. For example: <pre class="prettyprint"> class
 * MyGLSurfaceView extends GLSurfaceView {
 * 
 * private MyRenderer mMyRenderer;
 * 
 * public void start() { mMyRenderer = ...; setRenderer(mMyRenderer); }
 * 
 * public boolean onKeyDown(int keyCode, KeyEvent event) { if (keyCode ==
 * KeyEvent.KEYCODE_DPAD_CENTER) { queueEvent(new Runnable() { // This method
 * will be called on the rendering // thread: public void run() {
 * mMyRenderer.handleDpadCenter(); }}); return true; } return
 * super.onKeyDown(keyCode, event); } } </pre>
 * 
 */
public class GLSurfaceView extends SurfaceView implements SurfaceHolder.Callback
{
	/**
	 * The renderer only renders when the surface is created, or when
	 * {@link #requestRender} is called.
	 * 
	 * @see #getRenderMode()
	 * @see #setRenderMode(int)
	 */
	public final static int RENDERMODE_WHEN_DIRTY = 0;
	/**
	 * The renderer is called continuously to re-render the scene.
	 * 
	 * @see #getRenderMode()
	 * @see #setRenderMode(int)
	 * @see #requestRender()
	 */
	public final static int RENDERMODE_CONTINUOUSLY = 1;

	/**
	 * Check glError() after every GL call and throw an exception if glError
	 * indicates that an error has occurred. This can be used to help track down
	 * which OpenGL ES call is causing an error.
	 * 
	 * @see #getDebugFlags
	 * @see #setDebugFlags
	 */
	public final static int DEBUG_CHECK_GL_ERROR = 1;

	/**
	 * Log GL calls to the system log at "verbose" level with tag
	 * "GLSurfaceView".
	 * 
	 * @see #getDebugFlags
	 * @see #setDebugFlags
	 */
	public final static int DEBUG_LOG_GL_CALLS = 2;

	/**
	 * Standard View constructor. In order to render something, you must call
	 * {@link #setRenderer} to register a renderer.
	 */
	public GLSurfaceView(Context context)
	{
		super(context);
		init();
	}

	/**
	 * Standard View constructor. In order to render something, you must call
	 * {@link #setRenderer} to register a renderer.
	 */
	public GLSurfaceView(Context context, AttributeSet attrs)
	{
		super(context, attrs);
		init();
	}

	private void init()
	{
		// Install a SurfaceHolder.Callback so we get notified when the
		// underlying surface is created and destroyed
		SurfaceHolder holder = getHolder();
		holder.addCallback(this);
		holder.setType(SurfaceHolder.SURFACE_TYPE_GPU);
	}

	/**
	 * Set the glWrapper. If the glWrapper is not null, its
	 * {@link GLWrapper#wrap(GL)} method is called whenever a surface is
	 * created. A GLWrapper can be used to wrap the GL object that's passed to
	 * the renderer. Wrapping a GL object enables examining and modifying the
	 * behavior of the GL calls made by the renderer.
	 * <p>
	 * Wrapping is typically used for debugging purposes.
	 * <p>
	 * The default value is null.
	 * 
	 * @param glWrapper
	 *            the new GLWrapper
	 */
	public void setGLWrapper(GLWrapper glWrapper)
	{
		mGLWrapper = glWrapper;
	}

	/**
	 * Set the debug flags to a new value. The value is constructed by
	 * OR-together zero or more of the DEBUG_CHECK_* constants. The debug flags
	 * take effect whenever a surface is created. The default value is zero.
	 * 
	 * @param debugFlags
	 *            the new debug flags
	 * @see #DEBUG_CHECK_GL_ERROR
	 * @see #DEBUG_LOG_GL_CALLS
	 */
	public void setDebugFlags(int debugFlags)
	{
		mDebugFlags = debugFlags;
	}

	/**
	 * Get the current value of the debug flags.
	 * 
	 * @return the current value of the debug flags.
	 */
	public int getDebugFlags()
	{
		return mDebugFlags;
	}

	/**
	 * Set the renderer associated with this view. Also starts the thread that
	 * will call the renderer, which in turn causes the rendering to start.
	 * <p>
	 * This method should be called once and only once in the life-cycle of a
	 * GLSurfaceView.
	 * <p>
	 * The following GLSurfaceView methods can only be called <em>before</em>
	 * setRenderer is called:
	 * <ul>
	 * <li>{@link #setEGLConfigChooser(boolean)}
	 * <li>{@link #setEGLConfigChooser(EGLConfigChooser)}
	 * <li>{@link #setEGLConfigChooser(int, int, int, int, int, int)}
	 * </ul>
	 * <p>
	 * The following GLSurfaceView methods can only be called <em>after</em>
	 * setRenderer is called:
	 * <ul>
	 * <li>{@link #getRenderMode()}
	 * <li>{@link #onPause()}
	 * <li>{@link #onResume()}
	 * <li>{@link #queueEvent(Runnable)}
	 * <li>{@link #requestRender()}
	 * <li>{@link #setRenderMode(int)}
	 * </ul>
	 * 
	 * @param renderer
	 *            the renderer to use to perform OpenGL drawing.
	 */
	public void setRenderer(Renderer renderer)
	{
		if (mGLThread != null)
		{
			throw new IllegalStateException("setRenderer has already been called for this instance.");
		}
		if (mEGLConfigChooser == null)
		{
			mEGLConfigChooser = new SimpleEGLConfigChooser(true);
		}
		mGLThread = new GLThread(renderer);
		mGLThread.start();
	}

	/**
	 * Install a custom EGLConfigChooser.
	 * <p>
	 * If this method is called, it must be called before
	 * {@link #setRenderer(Renderer)} is called.
	 * <p>
	 * If no setEGLConfigChooser method is called, then by default the view will
	 * choose a config as close to 16-bit RGB as possible, with a depth buffer
	 * as close to 16 bits as possible.
	 * 
	 * @param configChooser
	 */
	public void setEGLConfigChooser(EGLConfigChooser configChooser)
	{
		if (mGLThread != null)
		{
			throw new IllegalStateException("setRenderer has already been called for this instance.");
		}
		mEGLConfigChooser = configChooser;
	}

	/**
	 * Install a config chooser which will choose a config as close to 16-bit
	 * RGB as possible, with or without an optional depth buffer as close to
	 * 16-bits as possible.
	 * <p>
	 * If this method is called, it must be called before
	 * {@link #setRenderer(Renderer)} is called.
	 * <p>
	 * If no setEGLConfigChooser method is called, then by default the view will
	 * choose a config as close to 16-bit RGB as possible, with a depth buffer
	 * as close to 16 bits as possible.
	 * 
	 * @param needDepth
	 */
	public void setEGLConfigChooser(boolean needDepth)
	{
		setEGLConfigChooser(new SimpleEGLConfigChooser(needDepth));
	}

	/**
	 * Install a config chooser which will choose a config with at least the
	 * specified component sizes, and as close to the specified component sizes
	 * as possible.
	 * <p>
	 * If this method is called, it must be called before
	 * {@link #setRenderer(Renderer)} is called.
	 * <p>
	 * If no setEGLConfigChooser method is called, then by default the view will
	 * choose a config as close to 16-bit RGB as possible, with a depth buffer
	 * as close to 16 bits as possible.
	 * 
	 */
	public void setEGLConfigChooser(int redSize, int greenSize, int blueSize, int alphaSize, int depthSize,
			int stencilSize)
	{
		setEGLConfigChooser(new ComponentSizeChooser(redSize, greenSize, blueSize, alphaSize, depthSize, stencilSize));
	}

	/**
	 * Set the rendering mode. When renderMode is RENDERMODE_CONTINUOUSLY, the
	 * renderer is called repeatedly to re-render the scene. When renderMode is
	 * RENDERMODE_WHEN_DIRTY, the renderer only rendered when the surface is
	 * created, or when {@link #requestRender} is called. Defaults to
	 * RENDERMODE_CONTINUOUSLY.
	 * <p>
	 * Using RENDERMODE_WHEN_DIRTY can improve battery life and overall system
	 * performance by allowing the GPU and CPU to idle when the view does not
	 * need to be updated.
	 * <p>
	 * This method can only be called after {@link #setRenderer(Renderer)}
	 * 
	 * @param renderMode
	 *            one of the RENDERMODE_X constants
	 * @see #RENDERMODE_CONTINUOUSLY
	 * @see #RENDERMODE_WHEN_DIRTY
	 */
	public void setRenderMode(int renderMode)
	{
		mGLThread.setRenderMode(renderMode);
	}

	/**
	 * Get the current rendering mode. May be called from any thread. Must not
	 * be called before a renderer has been set.
	 * 
	 * @return the current rendering mode.
	 * @see #RENDERMODE_CONTINUOUSLY
	 * @see #RENDERMODE_WHEN_DIRTY
	 */
	public int getRenderMode()
	{
		return mGLThread.getRenderMode();
	}

	/**
	 * Request that the renderer render a frame. This method is typically used
	 * when the render mode has been set to {@link #RENDERMODE_WHEN_DIRTY}, so
	 * that frames are only rendered on demand. May be called from any thread.
	 * Must not be called before a renderer has been set.
	 */
	public void requestRender()
	{
		mGLThread.requestRender();
	}

	/**
	 * This method is part of the SurfaceHolder.Callback interface, and is not
	 * normally called or subclassed by clients of GLSurfaceView.
	 */
	public void surfaceCreated(SurfaceHolder holder)
	{
		mGLThread.surfaceCreated();
	}

	/**
	 * This method is part of the SurfaceHolder.Callback interface, and is not
	 * normally called or subclassed by clients of GLSurfaceView.
	 */
	public void surfaceDestroyed(SurfaceHolder holder)
	{
		// Surface will be destroyed when we return
		mGLThread.surfaceDestroyed();
	}

	/**
	 * This method is part of the SurfaceHolder.Callback interface, and is not
	 * normally called or subclassed by clients of GLSurfaceView.
	 */
	public void surfaceChanged(SurfaceHolder holder, int format, int w, int h)
	{
		mGLThread.onWindowResize(w, h);
	}

	/**
	 * Inform the view that the activity is paused. The owner of this view must
	 * call this method when the activity is paused. Calling this method will
	 * pause the rendering thread. Must not be called before a renderer has been
	 * set.
	 */
	public void onPause()
	{
		mGLThread.onPause();
	}

	/**
	 * Inform the view that the activity is resumed. The owner of this view must
	 * call this method when the activity is resumed. Calling this method will
	 * recreate the OpenGL display and resume the rendering thread. Must not be
	 * called before a renderer has been set.
	 */
	public void onResume()
	{
		mGLThread.onResume();
	}

	/**
	 * Queue a runnable to be run on the GL rendering thread. This can be used
	 * to communicate with the Renderer on the rendering thread. Must not be
	 * called before a renderer has been set.
	 * 
	 * @param r
	 *            the runnable to be run on the GL rendering thread.
	 */
	public void queueEvent(Runnable r)
	{
		mGLThread.queueEvent(r);
	}

	/**
	 * This method is used as part of the View class and is not normally called
	 * or subclassed by clients of GLSurfaceView. Must not be called before a
	 * renderer has been set.
	 */
	@Override
	protected void onDetachedFromWindow()
	{
		super.onDetachedFromWindow();
		mGLThread.requestExitAndWait();
	}

	// ----------------------------------------------------------------------

	/**
	 * An interface used to wrap a GL interface.
	 * <p>
	 * Typically used for implementing debugging and tracing on top of the
	 * default GL interface. You would typically use this by creating your own
	 * class that implemented all the GL methods by delegating to another GL
	 * instance. Then you could add your own behavior before or after calling
	 * the delegate. All the GLWrapper would do was instantiate and return the
	 * wrapper GL instance: <pre class="prettyprint"> class MyGLWrapper
	 * implements GLWrapper { GL wrap(GL gl) { return new
	 * MyGLImplementation(gl); } static class MyGLImplementation implements
	 * GL,GL10,GL11,... { ... } } </pre>
	 * 
	 * @see #setGLWrapper(GLWrapper)
	 */
	public interface GLWrapper
	{
		/**
		 * Wraps a gl interface in another gl interface.
		 * 
		 * @param gl
		 *            a GL interface that is to be wrapped.
		 * @return either the input argument or another GL object that wraps the
		 *         input argument.
		 */
		GL wrap(GL gl);
	}

	/**
	 * A generic renderer interface.
	 * <p>
	 * The renderer is responsible for making OpenGL calls to render a frame.
	 * <p>
	 * GLSurfaceView clients typically create their own classes that implement
	 * this interface, and then call {@link GLSurfaceView#setRenderer} to
	 * register the renderer with the GLSurfaceView.
	 * <p>
	 * <h3>Threading</h3>
	 * The renderer will be called on a separate thread, so that rendering
	 * performance is decoupled from the UI thread. Clients typically need to
	 * communicate with the renderer from the UI thread, because that's where
	 * input events are received. Clients can communicate using any of the
	 * standard Java techniques for cross-thread communication, or they can use
	 * the {@link GLSurfaceView#queueEvent(Runnable)} convenience method.
	 * <p>
	 * <h3>EGL Context Lost</h3>
	 * There are situations where the EGL rendering context will be lost. This
	 * typically happens when device wakes up after going to sleep. When the EGL
	 * context is lost, all OpenGL resources (such as textures) that are
	 * associated with that context will be automatically deleted. In order to
	 * keep rendering correctly, a renderer must recreate any lost resources
	 * that it still needs. The {@link #onSurfaceCreated(GL10, EGLConfig)}
	 * method is a convenient place to do this.
	 * 
	 * 
	 * @see #setRenderer(Renderer)
	 */
	public interface Renderer
	{
		/**
		 * Called when the surface is created or recreated.
		 * <p>
		 * Called when the rendering thread starts and whenever the EGL context
		 * is lost. The context will typically be lost when the Android device
		 * awakes after going to sleep.
		 * <p>
		 * Since this method is called at the beginning of rendering, as well as
		 * every time the EGL context is lost, this method is a convenient place
		 * to put code to create resources that need to be created when the
		 * rendering starts, and that need to be recreated when the EGL context
		 * is lost. Textures are an example of a resource that you might want to
		 * create here.
		 * <p>
		 * Note that when the EGL context is lost, all OpenGL resources
		 * associated with that context will be automatically deleted. You do
		 * not need to call the corresponding "glDelete" methods such as
		 * glDeleteTextures to manually delete these lost resources.
		 * <p>
		 * 
		 * @param gl
		 *            the GL interface. Use <code>instanceof</code> to test if
		 *            the interface supports GL11 or higher interfaces.
		 * @param config
		 *            the EGLConfig of the created surface. Can be used to
		 *            create matching pbuffers.
		 */
		void onSurfaceCreated(GL10 gl, EGLConfig config);

		/**
		 * Called when the surface changed size.
		 * <p>
		 * Called after the surface is created and whenever the OpenGL ES
		 * surface size changes.
		 * <p>
		 * Typically you will set your viewport here. If your camera is fixed
		 * then you could also set your projection matrix here: <pre
		 * class="prettyprint"> void onSurfaceChanged(GL10 gl, int width, int
		 * height) { gl.glViewport(0, 0, width, height); // for a fixed camera,
		 * set the projection too float ratio = (float) width / height;
		 * gl.glMatrixMode(GL10.GL_PROJECTION); gl.glLoadIdentity();
		 * gl.glFrustumf(-ratio, ratio, -1, 1, 1, 10); } </pre>
		 * 
		 * @param gl
		 *            the GL interface. Use <code>instanceof</code> to test if
		 *            the interface supports GL11 or higher interfaces.
		 * @param width
		 * @param height
		 */
		void onSurfaceChanged(GL10 gl, int width, int height);

		/**
		 * Called to draw the current frame.
		 * <p>
		 * This method is responsible for drawing the current frame.
		 * <p>
		 * The implementation of this method typically looks like this: <pre
		 * class="prettyprint"> void onDrawFrame(GL10 gl) {
		 * gl.glClear(GL10.GL_COLOR_BUFFER_BIT | GL10.GL_DEPTH_BUFFER_BIT);
		 * //... other gl calls to render the scene ... } </pre>
		 * 
		 * @param gl
		 *            the GL interface. Use <code>instanceof</code> to test if
		 *            the interface supports GL11 or higher interfaces.
		 */
		void onDrawFrame(GL10 gl);
	}

	/**
	 * An interface for choosing an EGLConfig configuration from a list of
	 * potential configurations.
	 * <p>
	 * This interface must be implemented by clients wishing to call
	 * {@link GLSurfaceView#setEGLConfigChooser(EGLConfigChooser)}
	 */
	public interface EGLConfigChooser
	{
		/**
		 * Choose a configuration from the list. Implementors typically
		 * implement this method by calling {@link EGL10#eglChooseConfig} and
		 * iterating through the results. Please consult the EGL specification
		 * available from The Khronos Group to learn how to call
		 * eglChooseConfig.
		 * 
		 * @param egl
		 *            the EGL10 for the current display.
		 * @param display
		 *            the current display.
		 * @return the chosen configuration.
		 */
		EGLConfig chooseConfig(EGL10 egl, EGLDisplay display);
	}

	private static abstract class BaseConfigChooser implements EGLConfigChooser
	{
		public BaseConfigChooser(int[] configSpec)
		{
			mConfigSpec = configSpec;
		}

		public EGLConfig chooseConfig(EGL10 egl, EGLDisplay display)
		{
			int[] num_config = new int[1];
			egl.eglChooseConfig(display, mConfigSpec, null, 0, num_config);

			int numConfigs = num_config[0];

			if (numConfigs <= 0)
			{
				throw new IllegalArgumentException("No configs match configSpec");
			}

			EGLConfig[] configs = new EGLConfig[numConfigs];
			egl.eglChooseConfig(display, mConfigSpec, configs, numConfigs, num_config);
			EGLConfig config = chooseConfig(egl, display, configs);
			if (config == null)
			{
				throw new IllegalArgumentException("No config chosen");
			}
			return config;
		}

		abstract EGLConfig chooseConfig(EGL10 egl, EGLDisplay display, EGLConfig[] configs);

		protected int[] mConfigSpec;
	}

	private static class ComponentSizeChooser extends BaseConfigChooser
	{
		public ComponentSizeChooser(int redSize, int greenSize, int blueSize, int alphaSize, int depthSize,
				int stencilSize)
		{
			super(new int[] { EGL10.EGL_RED_SIZE, redSize, EGL10.EGL_GREEN_SIZE, greenSize, EGL10.EGL_BLUE_SIZE,
					blueSize, EGL10.EGL_ALPHA_SIZE, alphaSize, EGL10.EGL_DEPTH_SIZE, depthSize, EGL10.EGL_STENCIL_SIZE,
					stencilSize, EGL10.EGL_NONE });
			mValue = new int[1];
			mRedSize = redSize;
			mGreenSize = greenSize;
			mBlueSize = blueSize;
			mAlphaSize = alphaSize;
			mDepthSize = depthSize;
			mStencilSize = stencilSize;
		}

		@Override
		public EGLConfig chooseConfig(EGL10 egl, EGLDisplay display, EGLConfig[] configs)
		{
			EGLConfig closestConfig = null;
			int closestDistance = 1000;
			for (EGLConfig config : configs)
			{
				int r = findConfigAttrib(egl, display, config, EGL10.EGL_RED_SIZE, 0);
				int g = findConfigAttrib(egl, display, config, EGL10.EGL_GREEN_SIZE, 0);
				int b = findConfigAttrib(egl, display, config, EGL10.EGL_BLUE_SIZE, 0);
				int a = findConfigAttrib(egl, display, config, EGL10.EGL_ALPHA_SIZE, 0);
				int d = findConfigAttrib(egl, display, config, EGL10.EGL_DEPTH_SIZE, 0);
				int s = findConfigAttrib(egl, display, config, EGL10.EGL_STENCIL_SIZE, 0);
				int distance = Math.abs(r - mRedSize) + Math.abs(g - mGreenSize) + Math.abs(b - mBlueSize)
						+ Math.abs(a - mAlphaSize) + Math.abs(d - mDepthSize) + Math.abs(s - mStencilSize);
				if (distance < closestDistance)
				{
					closestDistance = distance;
					closestConfig = config;
				}
			}
			return closestConfig;
		}

		private int findConfigAttrib(EGL10 egl, EGLDisplay display, EGLConfig config, int attribute, int defaultValue)
		{

			if (egl.eglGetConfigAttrib(display, config, attribute, mValue))
			{
				return mValue[0];
			}
			return defaultValue;
		}

		private int[] mValue;
		// Subclasses can adjust these values:
		protected int mRedSize;
		protected int mGreenSize;
		protected int mBlueSize;
		protected int mAlphaSize;
		protected int mDepthSize;
		protected int mStencilSize;
	}

	/**
	 * This class will choose a supported surface as close to RGB565 as
	 * possible, with or without a depth buffer.
	 * 
	 */
	private static class SimpleEGLConfigChooser extends ComponentSizeChooser
	{
		public SimpleEGLConfigChooser(boolean withDepthBuffer)
		{
			super(4, 4, 4, 0, withDepthBuffer ? 16 : 0, 0);
			// Adjust target values. This way we'll accept a 4444 or
			// 555 buffer if there's no 565 buffer available.
			mRedSize = 5;
			mGreenSize = 6;
			mBlueSize = 5;
		}
	}

	/**
	 * An EGL helper class.
	 */

	private class EglHelper
	{
		public EglHelper()
		{

		}

		/**
		 * Initialize EGL for a given configuration spec.
		 * 
		 * @param configSpec
		 */
		public void start()
		{
			/*
			 * Get an EGL instance
			 */
			mEgl = (EGL10) EGLContext.getEGL();

			/*
			 * Get to the default display.
			 */
			mEglDisplay = mEgl.eglGetDisplay(EGL10.EGL_DEFAULT_DISPLAY);

			/*
			 * We can now initialize EGL for that display
			 */
			int[] version = new int[2];
			mEgl.eglInitialize(mEglDisplay, version);
			mEglConfig = mEGLConfigChooser.chooseConfig(mEgl, mEglDisplay);

			/*
			 * Create an OpenGL ES context. This must be done only once, an
			 * OpenGL context is a somewhat heavy object.
			 */
			mEglContext = mEgl.eglCreateContext(mEglDisplay, mEglConfig, EGL10.EGL_NO_CONTEXT, null);

			mEglSurface = null;
		}

		/*
		 * React to the creation of a new surface by creating and returning an
		 * OpenGL interface that renders to that surface.
		 */
		public GL createSurface(SurfaceHolder holder)
		{
			/*
			 * The window size has changed, so we need to create a new surface.
			 */
			if (mEglSurface != null)
			{

				/*
				 * Unbind and destroy the old EGL surface, if there is one.
				 */
				mEgl.eglMakeCurrent(mEglDisplay, EGL10.EGL_NO_SURFACE, EGL10.EGL_NO_SURFACE, EGL10.EGL_NO_CONTEXT);
				mEgl.eglDestroySurface(mEglDisplay, mEglSurface);
			}

			/*
			 * Create an EGL surface we can render into.
			 */
			mEglSurface = mEgl.eglCreateWindowSurface(mEglDisplay, mEglConfig, holder, null);

			/*
			 * Before we can issue GL commands, we need to make sure the context
			 * is current and bound to a surface.
			 */
			mEgl.eglMakeCurrent(mEglDisplay, mEglSurface, mEglSurface, mEglContext);

			GL gl = mEglContext.getGL();
			if (mGLWrapper != null)
			{
				gl = mGLWrapper.wrap(gl);
			}

			if ((mDebugFlags & (DEBUG_CHECK_GL_ERROR | DEBUG_LOG_GL_CALLS)) != 0)
			{
				int configFlags = 0;
				Writer log = null;
				if ((mDebugFlags & DEBUG_CHECK_GL_ERROR) != 0)
				{
					configFlags |= GLDebugHelper.CONFIG_CHECK_GL_ERROR;
				}
				if ((mDebugFlags & DEBUG_LOG_GL_CALLS) != 0)
				{
					log = new LogWriter();
				}
				gl = GLDebugHelper.wrap(gl, configFlags, log);
			}
			return gl;
		}

		/**
		 * Display the current render surface.
		 * 
		 * @return false if the context has been lost.
		 */
		public boolean swap()
		{
			mEgl.eglSwapBuffers(mEglDisplay, mEglSurface);

			/*
			 * Always check for EGL_CONTEXT_LOST, which means the context and
			 * all associated data were lost (For instance because the device
			 * went to sleep). We need to sleep until we get a new surface.
			 */
			return mEgl.eglGetError() != EGL11.EGL_CONTEXT_LOST;
		}

		public void finish()
		{
			if (mEglSurface != null)
			{
				mEgl.eglMakeCurrent(mEglDisplay, EGL10.EGL_NO_SURFACE, EGL10.EGL_NO_SURFACE, EGL10.EGL_NO_CONTEXT);
				mEgl.eglDestroySurface(mEglDisplay, mEglSurface);
				mEglSurface = null;
			}
			if (mEglContext != null)
			{
				mEgl.eglDestroyContext(mEglDisplay, mEglContext);
				mEglContext = null;
			}
			if (mEglDisplay != null)
			{
				mEgl.eglTerminate(mEglDisplay);
				mEglDisplay = null;
			}
		}

		EGL10 mEgl;
		EGLDisplay mEglDisplay;
		EGLSurface mEglSurface;
		EGLConfig mEglConfig;
		EGLContext mEglContext;
	}

	/**
	 * A generic GL Thread. Takes care of initializing EGL and GL. Delegates to
	 * a Renderer instance to do the actual drawing. Can be configured to render
	 * continuously or on request.
	 * 
	 */
	class GLThread extends Thread
	{
		GLThread(Renderer renderer)
		{
			super();
			mDone = false;
			mWidth = 0;
			mHeight = 0;
			mRequestRender = true;
			mRenderMode = RENDERMODE_CONTINUOUSLY;
			mRenderer = renderer;
			setName("GLThread");
		}

		@Override
		public void run()
		{
			/*
			 * When the android framework launches a second instance of an
			 * activity, the new instance's onCreate() method may be called
			 * before the first instance returns from onDestroy().
			 * 
			 * This semaphore ensures that only one instance at a time accesses
			 * EGL.
			 */
			try
			{
				try
				{
					sEglSemaphore.acquire();
				}
				catch (InterruptedException e)
				{
					return;
				}
				guardedRun();
			}
			catch (InterruptedException e)
			{
				// fall thru and exit normally
			}
			finally
			{
				sEglSemaphore.release();
			}
		}

		private void guardedRun() throws InterruptedException
		{
			mEglHelper = new EglHelper();
			mEglHelper.start();

			GL10 gl = null;
			boolean tellRendererSurfaceCreated = true;
			boolean tellRendererSurfaceChanged = true;

			/*
			 * This is our main activity thread's loop, we go until asked to
			 * quit.
			 */
            final ProfileRecorder profiler = ProfileRecorder.sSingleton;
			while (!mDone)
			{
                profiler.start(ProfileRecorder.PROFILE_FRAME);

				/*
				 * Update the asynchronous state (window size)
				 */
				int w, h;
				boolean changed;
				boolean needStart = false;
				synchronized (this)
				{
					Runnable r;
					while ((r = getEvent()) != null)
					{
						r.run();
					}
					if (mPaused)
					{
						mEglHelper.finish();
						needStart = true;
					}
					while (needToWait())
					{
						wait();
					}
					if (mDone)
					{
						break;
					}
					changed = mSizeChanged;
					w = mWidth;
					h = mHeight;
					mSizeChanged = false;
					mRequestRender = false;
				}
				if (needStart)
				{
					mEglHelper.start();
					tellRendererSurfaceCreated = true;
					changed = true;
				}
				if (changed)
				{
					gl = (GL10) mEglHelper.createSurface(getHolder());
					tellRendererSurfaceChanged = true;
				}
				if (tellRendererSurfaceCreated)
				{
					mRenderer.onSurfaceCreated(gl, mEglHelper.mEglConfig);
					tellRendererSurfaceCreated = false;
				}
				if (tellRendererSurfaceChanged)
				{
					mRenderer.onSurfaceChanged(gl, w, h);
					tellRendererSurfaceChanged = false;
				}
				if ((w > 0) && (h > 0))
				{
					/* draw a frame here */
                    profiler.start(ProfileRecorder.PROFILE_DRAW);
                    mRenderer.onDrawFrame(gl);
                    profiler.stop(ProfileRecorder.PROFILE_DRAW);
					
					/*
					 * Once we're done with GL, we need to call swapBuffers() to
					 * instruct the system to display the rendered frame
					 */
                    profiler.start(ProfileRecorder.PROFILE_PAGE_FLIP);
					mEglHelper.swap();
                    profiler.stop(ProfileRecorder.PROFILE_PAGE_FLIP);
				}
                profiler.stop(ProfileRecorder.PROFILE_FRAME);
                profiler.endFrame();
				
			}

			/*
			 * clean-up everything...
			 */
			mEglHelper.finish();
		}

		private boolean needToWait()
		{
			if (mDone)
			{
				return false;
			}

			if (mPaused || (!mHasSurface))
			{
				return true;
			}

			if ((mWidth > 0) && (mHeight > 0) && (mRequestRender || (mRenderMode == RENDERMODE_CONTINUOUSLY)))
			{
				return false;
			}

			return true;
		}

		public void setRenderMode(int renderMode)
		{
			if (!((RENDERMODE_WHEN_DIRTY <= renderMode) && (renderMode <= RENDERMODE_CONTINUOUSLY)))
			{
				throw new IllegalArgumentException("renderMode");
			}
			synchronized (this)
			{
				mRenderMode = renderMode;
				if (renderMode == RENDERMODE_CONTINUOUSLY)
				{
					notify();
				}
			}
		}

		public int getRenderMode()
		{
			synchronized (this)
			{
				return mRenderMode;
			}
		}

		public void requestRender()
		{
			synchronized (this)
			{
				mRequestRender = true;
				notify();
			}
		}

		public void surfaceCreated()
		{
			synchronized (this)
			{
				mHasSurface = true;
				notify();
			}
		}

		public void surfaceDestroyed()
		{
			synchronized (this)
			{
				mHasSurface = false;
				notify();
			}
		}

		public void onPause()
		{
			synchronized (this)
			{
				mPaused = true;
			}
		}

		public void onResume()
		{
			synchronized (this)
			{
				mPaused = false;
				notify();
			}
		}

		public void onWindowResize(int w, int h)
		{
			synchronized (this)
			{
				mWidth = w;
				mHeight = h;
				mSizeChanged = true;
				notify();
			}
		}

		public void requestExitAndWait()
		{
			// don't call this from GLThread thread or it is a guaranteed
			// deadlock!
			synchronized (this)
			{
				mDone = true;
				notify();
			}
			try
			{
				join();
			}
			catch (InterruptedException ex)
			{
				Thread.currentThread().interrupt();
			}
		}

		/**
		 * Queue an "event" to be run on the GL rendering thread.
		 * 
		 * @param r
		 *            the runnable to be run on the GL rendering thread.
		 */
		public void queueEvent(Runnable r)
		{
			synchronized (this)
			{
				mEventQueue.add(r);
			}
		}

		private Runnable getEvent()
		{
			synchronized (this)
			{
				if (mEventQueue.size() > 0)
				{
					return mEventQueue.remove(0);
				}

			}
			return null;
		}

		private boolean mDone;
		private boolean mPaused;
		private boolean mHasSurface;
		private int mWidth;
		private int mHeight;
		private int mRenderMode;
		private boolean mRequestRender;
		private Renderer mRenderer;
		private ArrayList<Runnable> mEventQueue = new ArrayList<Runnable>();
		private EglHelper mEglHelper;
	}

	static class LogWriter extends Writer
	{

		@Override
		public void close()
		{
			flushBuilder();
		}

		@Override
		public void flush()
		{
			flushBuilder();
		}

		@Override
		public void write(char[] buf, int offset, int count)
		{
			for (int i = 0; i < count; i++)
			{
				char c = buf[offset + i];
				if (c == '\n')
				{
					flushBuilder();
				}
				else
				{
					mBuilder.append(c);
				}
			}
		}

		private void flushBuilder()
		{
			if (mBuilder.length() > 0)
			{
				Log.v("GLSurfaceView", mBuilder.toString());
				mBuilder.delete(0, mBuilder.length());
			}
		}

		private StringBuilder mBuilder = new StringBuilder();
	}

	private static final Semaphore sEglSemaphore = new Semaphore(1);
	private boolean mSizeChanged = true;

	private GLThread mGLThread;
	private EGLConfigChooser mEGLConfigChooser;
	private GLWrapper mGLWrapper;
	private int mDebugFlags;
}
